//package cqrtplm.service.impl;
//
//import cn.hutool.core.collection.CollUtil;
//import com.alibaba.cloud.commons.lang.StringUtils;
//import com.alibaba.fastjson.JSON;
//import com.alibaba.fastjson.serializer.SerializerFeature;
//import com.hustcad.plm.basic.dto.defaultvalue.TyplmAttrDefaultValueDTO;
//import com.hustcad.plm.basic.dto.defaultvalue.TyplmDefaultValueParamDTO;
//import com.hustcad.plm.pdm.classification.model.vo.TyplmClassificationVO;
//import com.hustcad.plm.pdm.classification.service.TyplmClassificationCacheService;
//import com.hustcad.plm.pdm.common.model.dto.search.SearchConditionDTO;
//import com.hustcad.plm.pdm.common.model.vo.search.ResultEntityVO;
//import com.hustcad.plm.pdm.common.service.search.TyplmClassifySearchService;
//import com.hustcad.plm.pdm.defaultvalue.TyplmDefaultValueService;
//import com.hustcad.plm.pdm.iba.model.dto.SaveObjIBADTO;
//import com.hustcad.plm.pdm.iba.model.dto.TyplmAttributeDefMapDTO;
//import com.hustcad.plm.pdm.iba.service.TyplmAttributeDefService;
//import com.hustcad.plm.pdm.iba.service.TyplmAttributeValueService;
//import com.ty.basic.constant.TableTypeConstrant;
//import com.ty.basic.dto.constraint.IbaDTO;
//import com.ty.basic.entity.CTyEntityBaseDO;
//import com.ty.basic.entity.IdentifierEntity;
//import com.ty.basic.session.RequestContext;
//import com.ty.basic.vo.AttributeVO;
//import cqrtplm.dto.AttributeAndClassificationDTO;
//import cqrtplm.dto.GenerateDescriptionRuleDto;
//import cqrtplm.entity.DescribeSpliceRuleDO;
//import cqrtplm.mapper.DescribeSpliceRuleMapper;
//import cqrtplm.service.CodeSequenceService;
//import cqrtplm.vo.DescriptionVO;
//import lombok.Data;
//import lombok.extern.slf4j.Slf4j;
//import org.springframework.context.annotation.Primary;
//import org.springframework.stereotype.Service;
//import org.springframework.transaction.annotation.Transactional;
//
//import javax.annotation.Resource;
//import java.math.BigInteger;
//import java.util.*;
//import java.util.concurrent.CompletableFuture;
//import java.util.concurrent.ConcurrentHashMap;
//import java.util.function.Function;
//import java.util.stream.Collectors;
//
//@Primary
//@Slf4j
//@Service
//public class RTClassificationServiceBugFixImpl extends RTClassificationServiceImpl {
//
//
//    @Resource
//    private TyplmDefaultValueService typlmDefaultValueService;
//    @Resource
//    private TyplmClassifySearchService typlmClassifySearchService;
//    @Resource
//    private TyplmAttributeValueService typlmAttributeValueService;
//    @Resource
//    private TyplmAttributeDefService typlmAttributeDefService;
//    @Resource
//    private DescribeSpliceRuleMapper describeSpliceRuleMapper;
//    @Resource
//    private TyplmClassificationCacheService typlmClassificationCacheService;
//    @Resource
//    private CodeSequenceService codeSequenceService;
//
//    @Override
//    @Transactional(rollbackFor = Exception.class)
//    public void updateAttributeByClassification(AttributeAndClassificationDTO dto) {
//        long start = System.currentTimeMillis();
//        // 2. 获取属性默认值
//        Map<BigInteger, String> defaultValueMap = getAttributeDefaultValues(dto);
//        if (defaultValueMap.isEmpty()) {
//            log.info("没有找到属性默认值，无需更新");
//            return;
//        }
//        log.info("----------润通----getAttributeDefaultValues,耗时：{}---->>>", System.currentTimeMillis() - start);
//
//
//        start = System.currentTimeMillis();
//        // 3. 查询IBA属性定义
//        Map<BigInteger, TyplmAttributeDefMapDTO> attributeDefMap = getAttributeDefinitions(defaultValueMap.keySet());
//        log.info("----------润通----getAttributeDefinitions,耗时：{}---->>>", System.currentTimeMillis() - start);
//
//        start = System.currentTimeMillis();
//        // 4. 获取分类下的所有部件
//        ClassificationPartsResult partsResult = getClassificationParts(dto.getClassId());
//        log.info("-----------润通-----getClassificationParts----------{}", JSON.toJSONString(partsResult, SerializerFeature.PrettyFormat));
//
//        log.info("----------润通----getClassificationParts,耗时：{}---->>>", System.currentTimeMillis() - start);
//
//        start = System.currentTimeMillis();
//        // 5. 批量更新IBA属性
//        AttributeUpdateResult attributeUpdateResult = batchUpdateAttributes(partsResult, defaultValueMap, attributeDefMap);
//        log.info("----------润通----batchUpdateAttributes,耗时：{}---->>>", System.currentTimeMillis() - start);
//        start = System.currentTimeMillis();
//        // 6. 更新描述信息并收集结果
//        List<DescriptionResult> effectiveDescriptions = updatePartDescriptions(partsResult, attributeDefMap, attributeUpdateResult);
//        log.info("----------润通----updatePartDescriptions,耗时：{}---->>>", System.currentTimeMillis() - start);
//        log.info(">>>>>>>>>>>>>>>>{}",effectiveDescriptions);
//    }
//
//    /**
//     * 获取属性默认值
//     */
//    private Map<BigInteger, String> getAttributeDefaultValues(AttributeAndClassificationDTO dto) {
//        String classId = dto.getClassId();
//        List<String> attributeIds = dto.getAttributeIds();
//
//        Map<String, TyplmDefaultValueParamDTO> defaultValueParamMap = attributeIds.stream()
//                .collect(Collectors.toMap(
//                        attributeId -> TableTypeConstrant.TY_TYPE_OTYPE + ":" + classId,
//                        attributeId -> buildDefaultValueParam(attributeId, classId)
//                ));
//
//        Map<String, List<TyplmAttrDefaultValueDTO>> entityDefaultValueList =
//                typlmDefaultValueService.getEntityDefaultValueList(defaultValueParamMap);
//
//        return entityDefaultValueList.values().stream()
//                .flatMap(List::stream)
//                .filter(defaultValue -> StringUtils.isNotBlank(defaultValue.getDefaultValue()))
//                .collect(Collectors.toMap(
//                        TyplmAttrDefaultValueDTO::getAttributeReferenceOid,
//                        TyplmAttrDefaultValueDTO::getDefaultValue
//                ));
//    }
//
//    /**
//     * 构建默认值参数
//     */
//    private TyplmDefaultValueParamDTO buildDefaultValueParam(String attributeId, String classId) {
//        TyplmDefaultValueParamDTO paramDTO = new TyplmDefaultValueParamDTO();
//        paramDTO.setEntity(
//                new IdentifierEntity(new BigInteger(attributeId), TableTypeConstrant.TY_ATTRIBUTE_DEF_MAP_OTYPE));
//        paramDTO.setContext(new IdentifierEntity(new BigInteger(classId), TableTypeConstrant.TY_TYPE_OTYPE));
//        return paramDTO;
//    }
//
//    /**
//     * 获取属性定义
//     */
//    private Map<BigInteger, TyplmAttributeDefMapDTO> getAttributeDefinitions(Set<BigInteger> attributeOids) {
//        List<TyplmAttributeDefMapDTO> attributeDefs = typlmAttributeDefService.batchQueryAttributeMap(
//                new ArrayList<>(attributeOids));
//
//        return attributeDefs.stream()
//                .collect(Collectors.toMap(TyplmAttributeDefMapDTO::getAttributereferenceoid, Function.identity()));
//    }
//
//    /**
//     * 获取分类下的所有部件
//     */
//    private ClassificationPartsResult getClassificationParts(String classId) {
//        // 获取所有子分类
//        List<TyplmClassificationVO> subClassifications = typlmClassificationCacheService
//                .queryClassificationByParentID(new BigInteger(classId), "N");
//        Set<String> allClassOids = Collections.synchronizedSet(new HashSet<>());
//        allClassOids.add(classId);
//        Map<String, List<ResultEntityVO>> partsByClass = new ConcurrentHashMap<>();
//        // 先处理主分类
//        List<ResultEntityVO> mainParts = queryPartsByClassification(new BigInteger(classId));
//        partsByClass.put(classId, mainParts);
//        // 处理子分类
//        if (CollUtil.isNotEmpty(subClassifications)) {
//            // 将 subClassifications 平分成5份
//            List<List<TyplmClassificationVO>> chunks = splitList(subClassifications, 5);
//            List<CompletableFuture<Void>> futures = new ArrayList<>();
//            Map<String, Object> requestContext = RequestContext.currentContext();
//            for (List<TyplmClassificationVO> list : chunks) {
//                CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
//                    RequestContext.attachContext(requestContext);
//                    for (TyplmClassificationVO classification : list) {
//                        String classOid = classification.getId().toString();
//                        allClassOids.add(classOid);
//                        List<ResultEntityVO> parts = queryPartsByClassification(classification.getId());
//                        partsByClass.put(classOid, parts);
//                    }
//                });
//                futures.add(future);
//            }
//            // 等待所有异步任务完成
//            CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
//        }
//        // 收集所有部件OID
//        List<BigInteger> allPartOids = partsByClass.values().stream()
//                .filter(Objects::nonNull)
//                .flatMap(List::stream)
//                .filter(Objects::nonNull)
//                .map(ResultEntityVO::getOid)
//                .filter(Objects::nonNull)
//                .collect(Collectors.toList());
//        // 获取部件的IBA值
//        Map<String, List<AttributeVO>> partIbaValues = typlmAttributeValueService
//                .getAttrValueTableByEntitys(allPartOids, TableTypeConstrant.TY_PART_OTYPE);
//        return new ClassificationPartsResult(allClassOids, partsByClass, partIbaValues);
//    }
//
//    /**
//     * 将列表平分成指定份数
//     */
//    private <T> List<List<T>> splitList(List<T> originalList, int chunkCount) {
//        if (CollUtil.isEmpty(originalList) || chunkCount <= 0) {
//            return Collections.emptyList();
//        }
//
//        List<List<T>> chunks = new ArrayList<>();
//        int totalSize = originalList.size();
//        int chunkSize = (int) Math.ceil((double) totalSize / chunkCount);
//
//        for (int i = 0; i < chunkCount; i++) {
//            int fromIndex = i * chunkSize;
//            int toIndex = Math.min(fromIndex + chunkSize, totalSize);
//
//            if (fromIndex < totalSize) {
//                chunks.add(originalList.subList(fromIndex, toIndex));
//            }
//        }
//
//        return chunks;
//    }
//
//
//    /**
//     * 根据分类查询部件
//     */
//    private List<ResultEntityVO> queryPartsByClassification(BigInteger classificationOid) {
//        SearchConditionDTO condition = new SearchConditionDTO();
//        condition.setClassificationOid(classificationOid);
//        condition.setTypeInthid(TableTypeConstrant.TY_PART_OTYPE);
//        return typlmClassifySearchService.queryByCondition(condition);
//    }
//
//    /**
//     * 为单个部件构建IBA更新
//     */
//    private SaveObjIBADTO buildIbaUpdateForPart(ResultEntityVO part,
//                                                Map<BigInteger, String> defaultValueMap,
//                                                Map<BigInteger, TyplmAttributeDefMapDTO> attributeDefMap,
//                                                Map<String, List<AttributeVO>> partIbaValues) {
//
//        List<AttributeVO> partAttributes = partIbaValues.get(part.getOid().toString());
//        List<IbaDTO> ibaUpdates = new ArrayList<>();
//        boolean hasExistingAttributes = false;
//
//        // 处理已存在的属性
//        if (CollUtil.isNotEmpty(partAttributes)) {
//            for (AttributeVO attribute : partAttributes) {
//                BigInteger attributeOid = new BigInteger(attribute.getAttributeOid());
//                if (attributeDefMap.containsKey(attributeOid)) {
//                    hasExistingAttributes = true;
//                    if (StringUtils.isBlank(attribute.getAttributeValue())) {
//                        TyplmAttributeDefMapDTO attrDef = attributeDefMap.get(attributeOid);
//                        ibaUpdates.add(createIbaDTO(attrDef.getName(), defaultValueMap.get(attrDef.getOid())));
//                    }
//                }
//            }
//        }
//
//        // 如果部件没有这些属性，全部添加
//        if (!hasExistingAttributes) {
//            for (TyplmAttributeDefMapDTO attrDef : attributeDefMap.values()) {
//                ibaUpdates.add(createIbaDTO(attrDef.getName(), defaultValueMap.get(attrDef.getOid())));
//            }
//        }
//
//        if (CollUtil.isEmpty(ibaUpdates)) {
//            return null;
//        }
//
//        SaveObjIBADTO saveObjIBADTO = new SaveObjIBADTO();
//        saveObjIBADTO.setObjIbaList(ibaUpdates);
//        saveObjIBADTO.setCTyEntityBaseDO(new CTyEntityBaseDO(part.getOid(), part.getOtype()));
//        return saveObjIBADTO;
//    }
//
//    /**
//     * 获取拼接规则
//     */
//    private Map<String, DescribeSpliceRuleDO> getSpliceRules(Set<String> classOids) {
//        List<DescribeSpliceRuleDO> rules = describeSpliceRuleMapper.queryDescribeSpliceRuleBatch(
//                classOids, TableTypeConstrant.TY_CLASSIFICATION_OTYPE);
//        return rules.stream()
//                .collect(Collectors.toMap(DescribeSpliceRuleDO::getClassOid, Function.identity()));
//    }
//
//    /**
//     * 构建描述映射
//     */
//    private Map<String, List<String>> buildDescriptionMap(Map<String, DescribeSpliceRuleDO> spliceRules,
//                                                          Map<BigInteger, TyplmAttributeDefMapDTO> attributeDefMap) {
//        List<String> ibaNames = attributeDefMap.values().stream()
//                .map(TyplmAttributeDefMapDTO::getName)
//                .collect(Collectors.toList());
//
//        Map<String, List<String>> descriptionMap = new HashMap<>();
//
//        for (Map.Entry<String, DescribeSpliceRuleDO> entry : spliceRules.entrySet()) {
//            String displayRules = entry.getValue().getDescribeRules();
//            List<String> matchedNames = ibaNames.stream()
//                    .filter(displayRules::contains)
//                    .collect(Collectors.toList());
//
//            if (CollUtil.isNotEmpty(matchedNames)) {
//                descriptionMap.put(entry.getKey(), matchedNames);
//            }
//        }
//
//        return descriptionMap;
//    }
//
//
//    /**
//     * 创建描述IBA更新
//     */
//    private SaveObjIBADTO createDescriptionIbaUpdate(ResultEntityVO part, DescriptionVO description) {
//        List<IbaDTO> ibaList = new ArrayList<>();
//
//        if ("MaterialCode".equals(part.getTypeLogicalidentifier())) {
//            ibaList.add(createIbaDTO("MaterialCodeDescription", description.getSystemDescription()));
//        } else {
//            ibaList.add(createIbaDTO("CompleteDescription", description.getSystemDescription()));
//        }
//
//        ibaList.add(createIbaDTO("Description", description.getIbaDescription()));
//
//        SaveObjIBADTO saveObjIBADTO = new SaveObjIBADTO();
//        saveObjIBADTO.setObjIbaList(ibaList);
//        saveObjIBADTO.setCTyEntityBaseDO(new CTyEntityBaseDO(part.getOid(), part.getOtype()));
//        return saveObjIBADTO;
//    }
//
//    /**
//     * 使用图样代号更新描述
//     */
//    private void updateDescriptionWithPattern(SaveObjIBADTO update, DescriptionVO patternDescription) {
//        List<IbaDTO> ibaList = update.getObjIbaList();
//
//        for (IbaDTO iba : ibaList) {
//            if ("MaterialCodeDescription".equals(iba.getKey())) {
//                iba.setValue(patternDescription.getSystemDescription() + " ; " + iba.getValue());
//            } else if ("CompleteDescription".equals(iba.getKey())) {
//                iba.setValue(patternDescription.getIbaDescription() + " ; " + iba.getValue());
//            }
//        }
//
//        // 添加额外的IBA属性
//        ibaList.add(createIbaDTO("Common_Attributes|1757215074349", patternDescription.getSystemDescription()));
//        ibaList.add(createIbaDTO("PatternCodeDescription", patternDescription.getIbaDescription()));
//    }
//
//    /**
//     * 创建IBA DTO
//     */
//    private IbaDTO createIbaDTO(String key, String value) {
//        IbaDTO ibaDTO = new IbaDTO();
//        ibaDTO.setKey(key);
//        ibaDTO.setValue(value);
//        return ibaDTO;
//    }
//
//
//    /**
//     * 更新部件描述信息并收集结果
//     */
//    private List<DescriptionResult> updatePartDescriptions(ClassificationPartsResult partsResult,
//                                                           Map<BigInteger, TyplmAttributeDefMapDTO> attributeDefMap,
//                                                           AttributeUpdateResult attributeUpdateResult) {
//
//        // 创建收集结果的列表
//        List<DescriptionResult> effectiveDescriptions = Collections.synchronizedList(new ArrayList<>());
//
//        // 获取拼接规则
//        Map<String, DescribeSpliceRuleDO> spliceRules = getSpliceRules(partsResult.getClassOids());
//        Map<String, List<String>> descriptionMap = buildDescriptionMap(spliceRules, attributeDefMap);
//
//        if (descriptionMap.isEmpty()) {
//            log.info("没有找到需要更新描述的部件");
//            return effectiveDescriptions;
//        }
//
//        List<SaveObjIBADTO> descriptionUpdates = buildDescriptionUpdates(partsResult, descriptionMap, attributeUpdateResult, effectiveDescriptions);
//        if (CollUtil.isNotEmpty(descriptionUpdates)) {
//            typlmAttributeValueService.batchSaveIBAByObjsNoConstraint(descriptionUpdates, false);
//        }
//
//        return effectiveDescriptions;
//    }
//
//    /**
//     * 收集四种描述结果
//     */
//    private DescriptionResult collectDescriptionResult(ResultEntityVO part, String classOid, DescriptionVO description) {
//        DescriptionResult result = new DescriptionResult();
//        result.setPartOid(part.getOid());
//        result.setPartNumber(part.getObjectNumber());
//        result.setPartType(part.getTypeLogicalidentifier());
//        result.setClassOid(classOid);
//
//        // 收集四种描述
//        result.setSystemDescription(description.getSystemDescription());      // 系统描述
//        result.setIbaDescription(description.getIbaDescription());            // IBA描述
//        result.setMaterialCodeDescription("");  // 物料代号描述（稍后填充）
//        result.setCompleteDescription("");      // 完整描述（稍后填充）
//        result.setPatternCodeDescription("");   // 图样代号描述（稍后填充）
//        result.setCommonAttributesDescription(""); // 通用属性描述（稍后填充）
//
//        result.setGenerateTime(new Date());
//        result.setEffective(true);
//
//        return result;
//    }
//
//    /**
//     * 处理物料代号和图样代号的关联，并更新描述信息
//     */
//    private List<SaveObjIBADTO> processMaterialPatternAssociation(List<SaveObjIBADTO> descriptionUpdates,
//                                                                  Map<String, DescriptionVO> patternCodeDescriptions,
//                                                                  Map<BigInteger, String> materialCodePartNumbers,
//                                                                  List<DescriptionResult> effectiveDescriptions) {
//
//        // 创建部件OID到描述结果的映射，便于更新（只包含满足收集条件的）
//        Map<BigInteger, DescriptionResult> partDescriptionMap = effectiveDescriptions.stream()
//                .collect(Collectors.toMap(DescriptionResult::getPartOid, Function.identity()));
//
//        for (SaveObjIBADTO update : descriptionUpdates) {
//            BigInteger oid = update.getCTyEntityBaseDO().getOid();
//
//            // 对所有物料代号部件都进行关联处理（无论是否满足收集条件）
//            if (materialCodePartNumbers.containsKey(oid)) {
//                String partNumber = materialCodePartNumbers.get(oid);
//
//                for (Map.Entry<String, DescriptionVO> entry : patternCodeDescriptions.entrySet()) {
//                    if (partNumber.contains(entry.getKey())) {
//                        DescriptionVO patternDescription = entry.getValue();
//                        updateDescriptionWithPattern(update, patternDescription);
//
//                        // 只有满足收集条件的部件才更新描述结果
//                        if (partDescriptionMap.containsKey(oid)) {
//                            DescriptionResult descriptionResult = partDescriptionMap.get(oid);
//                            descriptionResult.setPatternCodeDescription(patternDescription.getIbaDescription());
//                            descriptionResult.setCommonAttributesDescription(patternDescription.getSystemDescription());
//
//                            // 更新物料代号描述和完整描述
//                            for (IbaDTO iba : update.getObjIbaList()) {
//                                if ("MaterialCodeDescription".equals(iba.getKey())) {
//                                    descriptionResult.setMaterialCodeDescription(iba.getValue());
//                                } else if ("CompleteDescription".equals(iba.getKey())) {
//                                    descriptionResult.setCompleteDescription(iba.getValue());
//                                }
//                            }
//                        }
//                    }
//                }
//            } else {
//                // 对于非物料代号的部件，如果满足收集条件，更新描述结果
//                if (partDescriptionMap.containsKey(oid)) {
//                    DescriptionResult descriptionResult = partDescriptionMap.get(oid);
//                    for (IbaDTO iba : update.getObjIbaList()) {
//                        if ("CompleteDescription".equals(iba.getKey())) {
//                            descriptionResult.setCompleteDescription(iba.getValue());
//                        } else if ("Description".equals(iba.getKey())) {
//                            descriptionResult.setIbaDescription(iba.getValue());
//                        }
//                    }
//                }
//            }
//        }
//
//        return descriptionUpdates;
//    }
//
//
//
//    /**
//     * 批量更新属性并收集属性映射
//     */
//    private AttributeUpdateResult batchUpdateAttributes(ClassificationPartsResult partsResult,
//                                                        Map<BigInteger, String> defaultValueMap,
//                                                        Map<BigInteger, TyplmAttributeDefMapDTO> attributeDefMap) {
//
//        Map<String, List<String>> attributeValueMap = new HashMap<>();
//        List<String> updatedPartOids = new ArrayList<>();
//        List<SaveObjIBADTO> objWithIbaList = new ArrayList<>();
//
//        // 批量更新属性
//        for (Map.Entry<String, List<ResultEntityVO>> entry : partsResult.getPartsByClass().entrySet()) {
//            List<ResultEntityVO> parts = entry.getValue();
//            for (ResultEntityVO part : parts) {
//                boolean hasExistingAttributes = false;
//                SaveObjIBADTO saveObjIBADTO = new SaveObjIBADTO();
//                List<IbaDTO> ibaDTOList = new ArrayList<>();
//
//                List<AttributeVO> partAttributes = partsResult.getPartIbaValues().get(part.getOid().toString());
//
//                // 处理已存在的属性
//                if (CollUtil.isNotEmpty(partAttributes)) {
//                    for (AttributeVO attributeVO : partAttributes) {
//                        String attributeOid = attributeVO.getAttributeOid();
//                        if (attributeDefMap.containsKey(new BigInteger(attributeOid))) {
//                            TyplmAttributeDefMapDTO attributeDef = attributeDefMap.get(new BigInteger(attributeOid));
//                            String attributeValue = attributeVO.getAttributeValue();
//                            hasExistingAttributes = true;
//
//                            if (StringUtils.isBlank(attributeValue)) {
//                                IbaDTO ibaDTO = new IbaDTO();
//                                ibaDTO.setKey(attributeVO.getAttributeEnName());
//                                ibaDTO.setValue(defaultValueMap.get(attributeDef.getOid()));
//                                ibaDTOList.add(ibaDTO);
//
//                                // 收集属性映射，用于后续生成描述
//                                attributeValueMap.put(attributeVO.getAttributeEnName(),
//                                                      Collections.singletonList(defaultValueMap.get(attributeDef.getOid())));
//                            }
//                        }
//                    }
//                }
//
//                // 如果部件没有这些属性，全部添加
//                if (!hasExistingAttributes) {
//                    for (Map.Entry<BigInteger, TyplmAttributeDefMapDTO> attributeEntry : attributeDefMap.entrySet()) {
//                        TyplmAttributeDefMapDTO attributeDef = attributeEntry.getValue();
//                        IbaDTO ibaDTO = new IbaDTO();
//                        ibaDTO.setKey(attributeDef.getName());
//                        ibaDTO.setValue(defaultValueMap.get(attributeDef.getOid()));
//                        ibaDTOList.add(ibaDTO);
//
//                        // 收集属性映射，用于后续生成描述
//                        attributeValueMap.put(attributeDef.getName(),
//                                              Collections.singletonList(defaultValueMap.get(attributeDef.getOid())));
//                    }
//                }
//
//                if (CollUtil.isNotEmpty(ibaDTOList)) {
//                    updatedPartOids.add(part.getOid().toString());
//                    saveObjIBADTO.setObjIbaList(ibaDTOList);
//                    saveObjIBADTO.setCTyEntityBaseDO(new CTyEntityBaseDO(part.getOid(), part.getOtype()));
//                    objWithIbaList.add(saveObjIBADTO);
//                }
//            }
//        }
//
//        // 执行批量保存
//        if (CollUtil.isNotEmpty(objWithIbaList)) {
//            typlmAttributeValueService.batchSaveIBAByObjsNoConstraint(objWithIbaList, false);
//        }
//
//        return new AttributeUpdateResult(attributeValueMap, updatedPartOids);
//    }
//
//    /**
//     * 构建描述更新列表并收集结果
//     */
//    private List<SaveObjIBADTO> buildDescriptionUpdates(ClassificationPartsResult partsResult,
//                                                        Map<String, List<String>> descriptionMap,
//                                                        AttributeUpdateResult attributeUpdateResult,
//                                                        List<DescriptionResult> effectiveDescriptions) {
//        List<SaveObjIBADTO> descriptionUpdates = new ArrayList<>();
//        Map<String, DescriptionVO> patternCodeDescriptions = new HashMap<>();
//        Map<BigInteger, String> materialCodePartNumbers = new HashMap<>();
//
//        for (String classOid : descriptionMap.keySet()) {
//            if (!partsResult.getPartsByClass().containsKey(classOid)) {
//                continue;
//            }
//
//            List<ResultEntityVO> parts = partsResult.getPartsByClass().get(classOid);
//            for (ResultEntityVO part : parts) {
//                // 只处理已更新属性的部件
//                if (!attributeUpdateResult.getUpdatedPartOids().contains(part.getOid().toString())) {
//                    continue;
//                }
//
//                // 构建IBA映射，包含原有的属性和新更新的属性
//                Map<String, List<String>> ibaMap = buildIbaMapForDescription(part, partsResult.getPartIbaValues(), attributeUpdateResult.getAttributeValueMap());
//
//                DescriptionVO description = generateDescriptionWithIbaMap(part, classOid, ibaMap);
//                if (description != null && isDescriptionRuleEffective(description)) {
//                    // 所有符合条件的部件都更新IBA
//                    SaveObjIBADTO ibaUpdate = createDescriptionIbaUpdate(part, description);
//                    descriptionUpdates.add(ibaUpdate);
//
//                    // 但只在满足特定条件时收集描述信息
//                    if ("MaterialCode".equals(part.getTypeLogicalidentifier()) || "Standard".equals(part.getTypeLogicalidentifier())) {
//                        String lifecyclestagekey = part.getLifecyclestagekey();
//                        if ("RELEASED".equals(lifecyclestagekey)) {
//                            DescriptionResult descriptionResult = collectDescriptionResult(part, classOid, description);
//                            effectiveDescriptions.add(descriptionResult);
//                        }
//                    }
//
//                    // 收集图样代号和物料代号信息（用于后续处理）
//                    if ("PatternCode".equals(part.getTypeLogicalidentifier())) {
//                        patternCodeDescriptions.put(part.getObjectNumber(), description);
//                    } else if ("MaterialCode".equals(part.getTypeLogicalidentifier())) {
//                        materialCodePartNumbers.put(part.getOid(), part.getObjectNumber());
//                    }
//                }
//            }
//        }
//
//        // 处理物料代号和图样代号的关联
//        return processMaterialPatternAssociation(descriptionUpdates, patternCodeDescriptions, materialCodePartNumbers, effectiveDescriptions);
//    }
//
//    /**
//     * 构建用于生成描述的IBA映射（合并原有属性和新更新属性）
//     */
//    private Map<String, List<String>> buildIbaMapForDescription(ResultEntityVO part,
//                                                                Map<String, List<AttributeVO>> partIbaValues,
//                                                                Map<String, List<String>> updatedAttributeMap) {
//        Map<String, List<String>> ibaMap = new HashMap<>();
//
//        // 添加原有的属性值
//        List<AttributeVO> partAttributes = partIbaValues.get(part.getOid().toString());
//        if (CollUtil.isNotEmpty(partAttributes)) {
//            for (AttributeVO attributeVO : partAttributes) {
//                String ibaName = attributeVO.getAttributeEnName();
//                List<String> values = ibaMap.computeIfAbsent(ibaName, k -> new ArrayList<>());
//                if (StringUtils.isNotBlank(attributeVO.getAttributeValue())) {
//                    values.add(attributeVO.getAttributeValue());
//                }
//            }
//        }
//
//        // 添加新更新的属性值（会覆盖原有的空值）
//        ibaMap.putAll(updatedAttributeMap);
//
//        return ibaMap;
//    }
//
//    /**
//     * 生成描述（使用合并后的IBA映射）
//     */
//    private DescriptionVO generateDescriptionWithIbaMap(ResultEntityVO part, String classOid, Map<String, List<String>> ibaMap) {
//        try {
//            GenerateDescriptionRuleDto ruleDto = new GenerateDescriptionRuleDto();
//            ruleDto.setIbaMap(ibaMap);
//            ruleDto.setType(part.getTypeLogicalidentifier());
//            ruleDto.setClassId(classOid);
//            ruleDto.setIsCheckCurrentDescriptionIfExist("false");
//            ruleDto.setIsMaterial("MaterialCode".equals(part.getTypeLogicalidentifier()) ? "true" : "false");
//
//            log.info("生成描述信息，部件编号: {}", part.getObjectNumber());
//            return codeSequenceService.generateDescriptionRule(ruleDto, Boolean.TRUE);
//        } catch (Exception e) {
//            log.error("生成部件{}的描述信息失败", part.getOid(), e);
//            return null;
//        }
//    }
//
//    /**
//     * 属性更新结果数据类
//     */
//    @Data
//    private static class AttributeUpdateResult {
//        private final Map<String, List<String>> attributeValueMap;  // 属性值映射
//        private final List<String> updatedPartOids;                // 已更新部件的OID列表
//
//        public AttributeUpdateResult(Map<String, List<String>> attributeValueMap, List<String> updatedPartOids) {
//            this.attributeValueMap = attributeValueMap;
//            this.updatedPartOids = updatedPartOids;
//        }
//    }
//
//
//
//
//    /**
//     * 判断描述规则是否生效
//     */
//    private boolean isDescriptionRuleEffective(DescriptionVO description) {
//        // 根据业务逻辑判断描述规则是否已生效
//        return StringUtils.isNotBlank(description.getSystemDescription())
//                && StringUtils.isNotBlank(description.getIbaDescription());
//    }
//
//    /**
//     * 描述结果数据类
//     */
//    @Data
//    private static class DescriptionResult {
//        private BigInteger partOid;                    // 部件OID
//        private String partNumber;                     // 部件编号
//        private String partType;                       // 部件类型
//        private String classOid;                       // 分类OID
//
//        // 四种描述
//        private String systemDescription;              // 系统描述
//        private String ibaDescription;                 // IBA描述
//        private String materialCodeDescription;        // 物料代号描述
//        private String completeDescription;            // 完整描述
//        private String patternCodeDescription;         // 图样代号描述
//        private String commonAttributesDescription;    // 通用属性描述
//
//        private Date generateTime;                     // 生成时间
//        private Boolean effective;                     // 是否生效
//    }
//
//
//    /**
//     * 内部类：分类部件结果
//     */
//    @Data
//    private static class ClassificationPartsResult {
//        private final Set<String> classOids;
//        private final Map<String, List<ResultEntityVO>> partsByClass;
//        private final Map<String, List<AttributeVO>> partIbaValues;
//        private Set<String> updatedPartOids = new HashSet<>();
//
//        public ClassificationPartsResult(Set<String> classOids,
//                                         Map<String, List<ResultEntityVO>> partsByClass,
//                                         Map<String, List<AttributeVO>> partIbaValues) {
//            this.classOids = classOids;
//            this.partsByClass = partsByClass;
//            this.partIbaValues = partIbaValues;
//        }
//    }
//
//}
